SpringBoot

搭建SpringBoot应用

需求:浏览发送/hello请求，服务器响应Hello,SpringBoot2

使用原生spring的弊端：使用原生spring的方式,需要导入spring和springMVC依赖，编写配置文件，开发代码，将tomcat引入idea，将应用部署在tomcat上启动运行,依赖管理麻烦，配置文件麻烦

maven配置

注意:需要在maven的settings.xml中profiles标签配置jdk的版本为8，避免编译过程使用其他版本

<mirrors>
  <mirror>
    <id>nexus-aliyun</id>
    <mirrorOf>central</mirrorOf>
    <name>Nexus aliyun</name>
    <url>http://maven.aliyun.com/nexus/content/groups/public</url>
  </mirror>
</mirrors>
<profiles>
     <profile>
          <id>jdk-1.8</id>
          <activation>
            <activeByDefault>true</activeByDefault>
            <jdk>1.8</jdk>
          </activation>
          <properties>
            <maven.compiler.source>1.8</maven.compiler.source>
            <maven.compiler.target>1.8</maven.compiler.target>
            <maven.compiler.compilerVersion>1.8</maven.compiler.compilerVersion>
          </properties>
     </profile>
</profiles>

web应用搭建

使用SpringBoot搭建一个简单的web应用实例

配置pom.xml

1. 在pom.xml中引入父工程spring-boot-starter-parent

2. 在pom.xml中引入web的场景启动器依赖spring-boot-starter-web

​x
    <!--向pom.xml中导入父工程spring-boot-starter-parent-->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.4.RELEASE</version>
    </parent>

    <!--配置web的场景启动器，用于springboot的web场景启动器的依赖
        导入这个依赖，web场景开发的日志，springMVC、spring核心等等的依赖都被导入进来
    -->
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>

主程序类

1. 编写主程序类如MainApplication

   • 必须用@SpringBootApplication注解告诉springBoot这是一个springboot应用，也称主程序类或主配置类

   • 在主程序类的主方法中编写代码SpringApplication.run(MainApplication.class,args)传入主程序类的class对象和主方法的args，该方法的作用相当于让主程序类对应的springboot应用跑起来

   • 可以直接运行主方法，也可以直接点debug运行SpringBoot应用

xxxxxxxxxx
/**
 * @author Earl
 * @version 1.0.0
 * @描述 主程序类，必须使用@SpringBootApplication注解告诉springBoot这是一个springboot应用，并且在主程序类的主方法中编写
 * SpringApplication.run(MainApplication.class,args)传入主程序类的class对象和主方法的args，该方法的作用相当于让主程序类对应的springboot
 * 应用跑起来
 * @创建日期 2023/05/17
 * @since 1.0.0
 */
@SpringBootApplication
public class MainApplication {
    public static void main(String[] args) {
        SpringApplication.run(MainApplication.class,args);
    }
}

业务代码

1. 在主程序类所在的包下创建控制器，编写对应/hello请求路径的对应控制器方法，并响应浏览器一段字符串，注意这里的/hello就是webapp的路径，即http://localhost:8080/hello

xxxxxxxxxx
//@ResponseBody//注意:这个注解可以标注在控制器类上，表示所有的控制器方法直接返回对象给浏览器。
//还可以直接用复合注解代替@ResponseBody和@Controller
//@Controller
@RestController
public class HelloController {
    @RequestMapping("/hello")
    //@ResponseBody
    public String handle01(){
        return "Hello,Spring Boot 2!";
    }
}

测试

1. 直接运行主程序的主方法即可(对比以前还需要整Tomcat和很多配置文件)

2. 也可以直接点击debug按钮或者运行符号

   经过测试，浏览器访问确实Ok

简化配置

springBoot最强大的功能是简化配置(比如改tomcat端口号，以前需要打开tomcat的配置文件改端口号)

1. springboot可以直接在类路径下的一个属性配置文件中修改所有的配置信息，该文件有固定名字application.properties

2. springboot本身有默认配置，在application.properties文件中可以进行修改的配置可以参考官方文档的Application Properties

   比如服务器的端口名固定为server.port;除此外还有配置的默认值信息

   使用ctrl+f能在文档中进行搜索,IDEA对属性名还有提示功能

xxxxxxxxxx
#application.properties文件中的配置示例，注意配置名是固定的
server.port=8888

简化部署

1. 使用springboot的spring-boot-maven-plugin插件把springboot应用打成一个可执行的jar包

   这个jar包称为小胖jar(fat.jars)，包含整个运行环境，可以直接通过DOS窗口的当前目录使用命令:

   java -jar boot-01-helloworld-1.0-SNAPSHOT.jar直接运行，经验证OK

    

   实际生产环境部署也是直接引入打包插件打成小胖jar，直接在目标服务器执行即可，注意:要关闭DOS命 令窗口的快速编辑模式，否则鼠标只要一点DOS命令窗口，springboot应用的启动进程就会卡住,以前 需要打成war包部署到服务器上

    

   小胖jar中BOOT-INF下的lib下是第三方的所有jar包,BOOT-INF下的classes下是我们自己写的代码和配置 文件

2. pom.xml插件配置代码

xxxxxxxxxx
<!--导入springboot把应用打成小胖jar的插件，注意:按视频那样不加版本号会报红，打包需要maven的clean和package操作-->
<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
            <version>2.3.4.RELEASE</version>
        </plugin>
    </plugins>
</build>

其他事项

1. DOS窗口检查java和mvn版本的命令

   • java -version

   • mvn -v

自动配置原理

SpringBoot两大优秀特性 : 依赖管理|自动配置

依赖管理

父工程做依赖管理

1. 在pom.xml使用父工程spring-boot-starter-parent进行依赖版本号管理

   xxxxxxxxxx
   使用父工程进行依赖管理
   <parent>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring-boot-starter-parent</artifactId>
       <version>2.3.4.RELEASE</version>
   </parent>
   

2. 父工程的pom.xml中还有父工程spring-boot-dependencies

   xxxxxxxxxx
   <parent>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring-boot-dependencies</artifactId>
       <version>2.3.4.RELEASE</version>
   </parent>
   

   • 在spring-boot-dependencies的pom.xml中的properties标签中声明了几乎开发中使用的所有jar包的版本

   • 使用ctrl+f可以搜索响应的依赖信息

   • 需要使用未被starter启动器引入的依赖，只需引入相关的groupId和artifactId，无需添加版本信息，默认使用父工程中设置的默认版本，注意引入非版本仲裁的jar要写版本号。

   • 如果想自己指定依赖的版本，直接在pom.xml中新建properties标签，依照spring-boot-dependencies中的依赖版本属性名格式配置自己想要的版本，springboot会自动根据就近原则选取用户自己配置的版本

     xxxxxxxxxx
     <properties>
         <mysql.version>5.1.43</mysql.version>
     </properties>
     

3. 导入starter场景启动器

   xxxxxxxxxx
   <!--配置web的场景启动器，用于springboot的web场景启动器的依赖
           导入这个依赖，web场景开发的日志，springMVC、spring核心等等的依赖都被导入进来
       -->
       <dependencies>
           <dependency>
               <groupId>org.springframework.boot</groupId>
               <artifactId>spring-boot-starter-web</artifactId>
           </dependency>
       </dependencies>
   

   官方文档的starter相关信息位置:Using Spring Boot下的starters

   • starter是一组依赖集合的描述，只要引入一个starter，这个starter开发场景的所有依赖都被引入了

     原理实际上是依赖的传递性，因为starter-*依赖依赖于开发某个场景所需要的全部依赖

   • Spring官方starter的命名规范:spring-boot-starter-**为某种场景

   • 第三方提供的starter的命名规范:*-spring-boot-starter

   • 所有starter的最基本依赖都是spring-boot-starter依赖

     xxxxxxxxxx
     所有场景启动器最底层的依赖
     <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter</artifactId>
         <version>2.3.4.RELEASE</version>
         <scope>compile</scope>
     </dependency>
     

自动配置

在spring-boot-starter-web的pom.xml下配置了Tomcat、SpringMVC等依赖

1. 自动配置Tomcat

   xxxxxxxxxx
   <dependency>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring-boot-starter-tomcat</artifactId>
       <version>2.3.4.RELEASE</version>
       <scope>compile</scope>
   </dependency>
   

   • 自动引入Tomcat依赖

   • 自动配置Tomcat，关于如何配置和启动Tomcat后面再讲

2. 自动配置SpringMVC

   • 自动引入SpringMVC全套组件

     xxxxxxxxxx
     <dependency>
       <groupId>org.springframework</groupId>
       <artifactId>spring-web</artifactId>
       <version>5.2.9.RELEASE</version>
       <scope>compile</scope>
     </dependency>
     <dependency>
       <groupId>org.springframework</groupId>
       <artifactId>spring-webmvc</artifactId>
       <version>5.2.9.RELEASE</version>
       <scope>compile</scope>
     </dependency>
     

   • 自动配好了SpringMVC的常用组件(功能)

     • DispatcherServlet

     • characterEncoding?是视图解析器的属性吗，作为属性为什么可以作为IoC容器的组件?

     • viewResolver 视图解析器

     • mutipartResolver 文件上传解析器

     • ...SpringBoot已经帮用户配置好了所有的web开发常见场景，会自动在容器中生效，生效原理以后再说

       以上组件都可以获取IoC容器并获取组件名字打印查看

3. springboot中默认的包扫描规则

   • 官方文档的Using Spring Boot下的Structuring Your Code下有默认包扫描规则

   • 默认规则为主程序所在的包及该包下的所有子包都能被扫描到，无需再配置包扫描

   • 如果必须要扫描主程序类所在包外的包或类，可以在标注主程序类的@SpringBootApplication注解中为其属性scanBasePackages赋值更大的扫描范围即可

     xxxxxxxxxx
     //由于@SpringBootApplication由@ComponentScan注解复合而成，所以不能直接在主程序类上使用@ComponentScan扩大扫描范围，会提示注解重复
     @SpringBootApplication(scanBasePackages = "com.atlisheng")
     

   • 可以直接把@SpringBootApplication注解拆成三个注解，并在注解之一@ComponentScan中扩大包扫描的范围，这样不会报注解重复异常

     xxxxxxxxxx
     @SpringBootApplication(scanBasePackages = "com.atlisheng")
     等同于
     @SpringBootConfiguration
     @EnableAutoConfiguration
     @ComponentScan("com.atlisheng")
     

4. 自动配置的默认值

   • SpringBoot的自动配置都有默认值，如果想要修改直接在application.properties文件中修改对应的key和value即可

   • 默认配置最终都是映射到某个类上，如：MultipartProperties

     配置文件的值最终会绑定每个类上，这个类会在容器中创建对象

     研究如何映射绑定和使用后面介绍

5. 自动配置按需加载

   • 引入了哪些场景启动器，对应的自动配置才会开启

   • SpringBoot所有的自动配置功能都在spring-boot-starter包依赖的spring-boot-autoconfigure 包里面，在外部libirary中的autoconfigure中可以找到，里面按照amqp、aop、拼接码、缓存、批处理等等场景按包进行了分类，这些自动配置类中发红的对象就是没有生效的，比如批处理，导入批处理场景启动器spring-boot-starter-batch部分报红的对象就会恢复正常

底层注解

@Configuration

@Configuration配置类

原生Spring向IoC容器中添加bean对象的方式:

• 在xml文件中用bean标签向IoC容器添加bean对象(组件)

• 在类上标注@Component、@Controller、@Service、@Repository注解代表该类是一个组件

• 配置类示例:

  xxxxxxxxxx
  @Configuration(proxyBeanMethods = true)//告诉SpringBoot这是一个配置类，可以取代配置文件的作用，注意:配置类也是IoC容器的一个组件
  //@Configuration(proxyBeanMethods = false)
  public class MyConfig {
      @Bean//配置类中使用@Bean注解标注方法可以给容器注册组件，默认是单实例的，
      // 方法名将作为组件的id，返回类型就是组件类型。返回的值就是组件在容器中的实例
      public User user01(){
          User zhangsan = new User("zhangsan", 18);
          //user组件依赖了Pet组件
          zhangsan.setPet(tomcatPet());
          return zhangsan;
      }
      @Bean("tom")
      public Pet tomcatPet(){
          return new Pet("tomcat");
      }
  }
  

• Configuration配置类测试代码

  xxxxxxxxxx
  public static void main(String[] args) {
      ConfigurableApplicationContext run = SpringApplication.run(MainApplication.class, args);
      //从容器中获取组件
      Pet tom01=run.getBean("tom",Pet.class);
      Pet tom02=run.getBean("tom",Pet.class);
      System.out.println("组件:"+((tom01==tom02)?"单实例":"多实例"));
  
      //配置类也是一个组件，可以从容器中获取，从对象引用可以看出配置类是一个被CGLIB增强的代理对象
      MyConfig bean = run.getBean(MyConfig.class);
      System.out.println(bean);
      //com.atlisheng.boot.config.MyConfig$$EnhancerBySpringCGLIB$$a82a58f4@47ffe971
  
      //外部调用配置类的组件注册方法无论多少遍获取的都是注册在容器中的单实例对象
      //如果@Configuration(proxyBeanMethods = true)默认值就是true，此时配置类使用代理对象调用组件注册方法，SpringBoot总会检查该组件是否已在容器中存在如果有会自动保持组件单实例
      //如果@Configuration(proxyBeanMethods = false)，此时配置类不会使用调用组件注册方法，SpringBoot不会保持该组件的单实例
      User user=bean.user01();
      User user1=bean.user01();
      System.out.println("组件:"+((user==user1)?"单实例":"多实例"));
  
      User user01 = run.getBean("user01", User.class);
      Pet tom = run.getBean("tom", Pet.class);
      System.out.println("用户"+(user01.getPet()==tom?"user01依赖于组件tom":"user01不依赖于组件tom"));
  }
  

1. 使用@Configuration(意为配置)标注类可以告诉SpringBoot这个类是一个配置类，可以取代Spring配置文件的作用，配置文件的功能这个类都有，配置类本身也是IoC容器的组件

2. 在配置类中使用@Bean注解标注组件注册方法，方法返回的对象会被作为组件自动纳入IoC容器的管理

   以方法名作为组件的id，返回的类型就是组件类型，返回的值就是组件在容器中的实例

   添加@Bean注解的value属性可以手动设置组件的id

   默认被注册组件是单实例的

3. @Configuration注解的proxyBeanMethods属性

   • proxyBeanMethods属性为true时(即Full模式，全配置):

     此时配置类在容器中是被CGLIB增强的代理对象，使用代理对象调用组件注册方法，SpringBoot总会检查该组件是否已在容器中存在如果有会自动保持组件单实例

     实现原理是容器中有自动去容器中找组件

   • proxyBeanMethods属性为false时(即Lite模式，轻量级配置):

     此时配置类在容器中是普通对象，调用组件注册方法时，SpringBoot不会保持目标组件的单实例

4. proxyBeanMethods属性可以用来方便的处理组件依赖的场景

   如User中有Pet属性，user想获取容器中已经注册的Pet组件，直接在Full模式下调用配置类的pet组件注册方法即可，注意Lite模式下这种方式为user获取的pet属性不是已经在容器中注册的组件

   • proxyBeanMethods属性的最佳实践

    

@Import

@Import导入组件

@Import注解的作用也是给IoC容器中导入一个组件

1. @Import注解需要标注在配置类或者组件类的类名上

   • 该注解的value属性是一个class数组，可以导入用户或者第三方的类的class对象

   • 作用是将指定类型的组件导入IoC容器，调用对应类型的无参构造创建出对应的组件对象

   • 通过@Import注解导入的组件的默认名字是对应类型的全限定类名

   ~@Import注解使用实例

   xxxxxxxxxx
   @Import({User.class, DBHelper.class})
   @Configuration(proxyBeanMethods = false) //告诉SpringBoot这是一个配置类 == 配置文件
   public class MyConfig {
   }
   

   ~@Import注解的测试代码

   xxxxxxxxxx
   public static void main(String[] args) {
       ConfigurableApplicationContext run = SpringApplication.run(MainApplication.class, args);
       //从容器中根据类型获取该类型对应的所有组件名字
       String[] users = run.getBeanNamesForType(User.class);
       Arrays.stream(users).forEach(user2->{
           System.out.println(user2);
       });
       //从容器中根据类型获取单个组件
       DBHelper bean1 = run.getBean(DBHelper.class);
       System.out.println(bean1);
   }
   

2. @Import注解还有高级用法，参考：08尚硅谷组件注册-@Import-给容器中快速导入一个组件

@Conditional

@Conditional条件装配

@Conditional条件装配注解的作用是：满足Conditional指定的条件，则对标注组件进行组件注入

1. @Conditional是一个根注解，其下派生出非常多的派生注解

   • 派生注解可以标注在组件注册方法上，表示条件装配只对该方法对应的组件生效

   • 派生注解也可以标注在配置类或者组件类上，表示条件装配对配置类下的所有组件均有效或对组件类有效

2. @Conditional的常用派生注解

   • @ConditionalOnBean

     当容器中存在用户指定的组件时才向容器注入指定的组件

   • @ConditionalOnMissingBean

     当容器中没有用户指定的组件时才向容器注入指定的组件，没有指定就表示容器中没有当前组件就配置当前组件，配置了当前组件就不配置了

   • @ConditionalOnClass

     当容器中存在用户指定的类时才向容器注入指定的组件

   • @ConditionalOnMissingClass

     当容器中没有用户指定的类时才向容器注入指定的组件

   • @ConditionalOnResource

     当类路径下存在用户指定的资源时才向容器注入指定的组件

   • @ConditionalOnJava

     当Java是用户指定的版本号时才向容器注入指定的组件

   • @ConditionalOnWebApplication

     当应用是一个web应用时才向容器注入指定的组件

   • @ConditionalOnWebApplication

     当应用不是一个web应用时才向容器注入指定的组件

   • @ConditionalOnSingleCandidate

     当特定组件只有一个实例或者多个实例中有一个主实例时才向容器注入指定的组件

   • @ConditionalOnProperty

     当配置文件中配置了特定属性时才向容器注入指定的组件

3. 以@ConditionalOnBean举例说明@Conditional派生注解的用法

   ~@ConditionalOnBean和@ConditionalOnMissingBean代码实例:

   xxxxxxxxxx
   @Configuration(proxyBeanMethods = true)
   //@ConditionalOnBean(name="tom")//标注在类上表示当容器中有组件tom时这个类中所有的注册组件才生效
   @ConditionalOnMissingBean(name="tom")//标注在类上表示当容器中没有组件tom时这个类中所有的注册组件才生效
   public class MyConfig {
       @Bean
       //需求:因为user01依赖于tom，如果容器中没有tom组件就不要在容器中注册user01组件了
       //@ConditionalOnBean(name="tom")
       //@ConditionalOnBean中有很多属性，value、name等，分别表示class对象或者组件id
       //@ConditionalOnBean(name="tom")标注在组件注册方法上时，当容器中有tom时再通过组件注册方法注册user01
       //Q:判断放在什么时候，如果user01组件先注册怎么办?暂时对结果没有影响
       public User user01(){
           User zhangsan = new User("zhangsan", 18);
           //user组件依赖了Pet组件
           zhangsan.setPet(tomcatPet());
           return zhangsan;
       }
       //@Bean("tom")
       @Bean("tom22")
       public Pet tomcatPet(){
           return new Pet("tomcat");
       }
   }
   

   ~测试代码:

   xxxxxxxxxx
   public static void main(String[] args) {
       ConfigurableApplicationContext run = SpringApplication.run(MainApplication.class, args);
       boolean tom = run.containsBean("tom");
       System.out.println("容器中Tom组件:"+(tom?"存在":"不存在"));
   
       boolean user01 = run.containsBean("user01");
       System.out.println("容器中user01组件:"+(user01?"存在":"不存在"));
   
       boolean tom22 = run.containsBean("tom22");
       System.out.println("容器中tom22组件:"+(tom22?"存在":"不存在"));
   }
   

@ImportResource

@ImportResource导入Spring配置文件

有些公司还在使用spring.xml配置IoC组件，这些xml文件需要使用BeanFactory applicationContext=new ClassPathXmlApplicationContext("spring.xml");获取Bean工厂才能创建对应的IoC容器并生成对应的组件,无法直接生效在springboot的IoC容器中生成对应的组件，使用SpringBoot需要对应去添加配置类和@Bean注解来生成组件，很麻烦

1. SpringBoot提供@ImportResource注解配置在随意配置类上导入Spring配置文件，使配置文件中的组件在springboot的IoC容器中生效，无需添加配置类和@Bean注解

   ~beans.xml配置代码

   xxxxxxxxxx
   <?xml version="1.0" encoding="UTF-8"?>
   <beans xmlns="http://www.springframework.org/schema/beans"
          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
       <bean id="user01" class="com.atlisheng.boot.bean.User">
           <property name="name" value="zhangsan"/>
           <property name="age" value="18"/>
       </bean>
       <bean id="cat" class="com.atlisheng.boot.bean.Pet">
           <property name="name" value="tomcat"/>
       </bean>
   </beans>
   

   ~@ImportResource注解用法实例

   xxxxxxxxxx
   @Configuration
   @ImportResource("classpath:beans.xml")
   public class MyConfig {
       ...
   }
   

   ~测试代码

   xxxxxxxxxx
   public static void main(String[] args) {
       ConfigurableApplicationContext run = SpringApplication.run(MainApplication.class, args);
       boolean haha = run.containsBean("haha");
       boolean hehe = run.containsBean("hehe");
       System.out.println("haha:"+(haha?"存在":"不存在"));
       System.out.println("hehe:"+(hehe?"存在":"不存在"));
   }
   

    

@ConfigurationProperties

@ConfigurationProperties配置绑定

配置绑定就是使用Java读取配置文件中的内容，并将数据封装到JavaBean中，如数据库连接信息封装到数据源中，对于配置项上百行的配置文件有时需要使用正则表达式来进行匹配寻找，非常麻烦

~传统方式代码

xxxxxxxxxx
public class getProperties {
     public static void main(String[] args) throws FileNotFoundException, IOException {
         Properties pps = new Properties();
         pps.load(new FileInputStream("a.properties"));
         Enumeration enum1 = pps.propertyNames();//得到配置文件的名字
         while(enum1.hasMoreElements()) {
             String strKey = (String) enum1.nextElement();
             String strValue = pps.getProperty(strKey);
             System.out.println(strKey + "=" + strValue);
             //封装到JavaBean。
         }
     }
 }

springboot提供了两种配置绑定的方案

1. 方案一：@ConfigurationProperties + @Component

   • 步骤一：在配置文件application.properties中对目标类Car依据属性进行了如下配置

     xxxxxxxxxx
     mycar.brand=BYD
     mycar.price=100000
     

   • 步骤二：确认目标类Car被纳入了IoC容器管理，只有被纳入IoC容器管理的组件才能享受类似配置绑定等其他spring强大功能

   • 步骤三：在目标类上使用@ConfigurationProperties(prefix = "mycar")注解通知springboot自动根据前缀mycar查找application.properties对应含有前缀的key如mycar.brand和mycar.price,并将值通过目标类的set注入注入属性值，注意value属性和prefix属性互为别名，使用哪一个都可以

     ~配置绑定代码

     xxxxxxxxxx
     @Component
     @ConfigurationProperties(prefix = "mycar")
     @ConfigurationProperties(prefix = "mycar")
     public class Car {
         private String brand;
         private Integer price;
         ...这种方式必须写set方法...
     }
     

2. 方案二：@EnableConfigurationProperties + @ConfigurationProperties

   • 步骤一：在配置文件application.properties中对目标类Car进行属性配置

   • 步骤二：在配置类上使用@EnableConfigurationProperties注解对配置类进行标注，注解的value属性为目标类的class对象，这一步的目的:

     • 根据class对象开启目标类的配置绑定功能

     • 把目标类这个组件自动注册到容器中

       xxxxxxxxxx
       @EnableConfigurationProperties(Car.class)
       public class MyConfig {
       ...
       }
       

   • 步骤三：在目标类上使用@ConfigurationProperties注解指定前缀属性prefix进行配置绑定

     xxxxxxxxxx
     @ConfigurationProperties(prefix = "mycar")
     public class Car {
     ...
     }
     

      

自动配置原理

包扫描规则

@SpringBootApplication

1. 核心注解@SpringBootApplication是一个复合注解，用来标注主程序类，该注解相当于@ComponentScan、@SpringBootConfiguration、@EnableAutoConfiguration三个注解的合成注解，从这三个注解的功能就能反应@SpringBootApplication的核心功能

   xxxxxxxxxx
   @Target(ElementType.TYPE)
   @Retention(RetentionPolicy.RUNTIME)
   @Documented
   @Inherited
   @SpringBootConfiguration
   @EnableAutoConfiguration
   @ComponentScan(excludeFilters = { 
       @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
       @Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
   public @interface SpringBootApplication {
   ...
   }
   

@SpringBootConfiguration

1. @Configuration注解是@SpringBootConfiguration元注解，表明@SpringBootConfiguration标注的类也是一个配置类，即主程序类是一个核心配置类

   xxxxxxxxxx
   @Target(ElementType.TYPE)
   @Retention(RetentionPolicy.RUNTIME)
   @Documented
   @Configuration
   public @interface SpringBootConfiguration {
       @AliasFor(annotation = Configuration.class)
       boolean proxyBeanMethods() default true;
   }
   

@ComponentScan

1. 包扫描注解，指定要扫描哪些包，包扫描注解@ComponentScan有两个SpringBoot自定义的扫描器

   雷丰阳的spring注解视频中有介绍：尚硅谷Spring注解驱动教程(雷丰阳源码级讲解)

@EnableAutoConfiguration

1. @EnableAutoConfiguration也是一个合成注解，由注解@AutoConfigurationPackage以及组件导入@Import(AutoConfigurationImportSelector.class)构成

   xxxxxxxxxx
   @Target(ElementType.TYPE)
   @Retention(RetentionPolicy.RUNTIME)
   @Documented
   @Inherited
   @AutoConfigurationPackage
   @Import(AutoConfigurationImportSelector.class)
   public @interface EnableAutoConfiguration {
       String ENABLED_OVERRIDE_PROPERTY = "spring.boot.enableautoconfiguration";
       Class<?>[] exclude() default {};
       String[] excludeName() default {};
   }
   

2. @AutoConfigurationPackage

   @AutoConfigurationPackage注解的作用就是实现了默认包扫描范围为主程序类所在包及其所有子包

   • @AutoConfigurationPackage意为自动配置包，由其源码：@Import(AutoConfigurationPackages. Registrar.class)，可知该注解就是给容器导入Registrar组件，通过Registrar组件的registerBeanDefinitions方法给容器导入一系列组件

     xxxxxxxxxx
     @Target(ElementType.TYPE)
     @Retention(RetentionPolicy.RUNTIME)
     @Documented
     @Inherited
     @Import(AutoConfigurationPackages.Registrar.class)//给容器中导入一个组件
     public @interface AutoConfigurationPackage {
         String[] basePackages() default {};
         Class<?>[] basePackageClasses() default {};
     }
     

   • Registrar类的registerBeanDefinitions方法分析

     xxxxxxxxxx
     static class Registrar implements ImportBeanDefinitionRegistrar, DeterminableImports {
         @Override
         public void registerBeanDefinitions(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {
             register(registry, new PackageImports(metadata).getPackageNames().toArray(new String[0]));
         }
         @Override
         public Set<Object> determineImports(AnnotationMetadata metadata) {
             return Collections.singleton(new PackageImports(metadata));
         }
     }
     

     • 通过Registrar组件的registerBeanDefinitions(AnnotationMetadata metadata, BeanDefinitionRegister)方法执行批量导入组件的操作，这些组件即主程序类MainApplication所在包及其所有子包下的组件

     • AnnotationMetadata metadata是注解源信息，该注解指的是@AutoConfigurationPackage，注解的源信息包括了该注解的标注位置MainApplication的全限定类名以及该注解有哪些属性值

       [因为@AutoConfigurationPackage合成了注解@EnableAutoConfiguration，最终相当于@AutoConfigurationPackage注解标注在主程序类MainApplication上，在registerBeanDefinitions方法中new PackageImports(metadata).getpackageName(). toArray(new Array[0])通过元注解信息获取到组件所在的包名，即主程序类所在的包名，封装在数组中然后使用register方法进行注册，这就是默认包扫描范围在主程序类MainApplication所在包及其所有子包下的原因]

加载自动配置类

初始化时加载的相关自动配置类

3. @Import(AutoConfigurationImportSelector.class)

   • @Import(AutoConfigurationImportSelector.class)注解是@EnableAutoConfiguration注解的组分之一

   • 利用selector机制引入AutoConfigurationImportSelector组件给容器批量导入组件

     • AutoConfigurationImportSelector中的selectImports方法返回的字符串数组中规定了要批量导入组件的列表，该列表是调用getAutoConfigurationEntry(annotationMetadata)获取的；重点就是方法：getAutoConfigurationEntry(annotationMetadata)

       xxxxxxxxxx
       public class AutoConfigurationImportSelector implements DeferredImportSelector, BeanClassLoaderAware,ResourceLoaderAware, BeanFactoryAware, EnvironmentAware, Ordered {
           ...
           @Override
           public String[] selectImports(AnnotationMetadata annotationMetadata) {
               if (!isEnabled(annotationMetadata)) {
                   return NO_IMPORTS;
               }
               AutoConfigurationEntry autoConfigurationEntry = getAutoConfigurationEntry(annotationMetadata);
               return StringUtils.toStringArray(autoConfigurationEntry.getConfigurations());
           }
           ...
       }
       

     • getAutoConfigurationEntry(annotationMetadata)方法解析:

       • 该方法获取所有需要自动配置的集合

       • getCandidateConfigurations(annotationMetadata, attributes)方法，作用是获取所有备选的配置，返回configurations；

       • 接下来依次对configurations移除重复的选项，排除一些配置选项，以及一些额外操作封装成AutoConfigurationEntry进行返回，在没有重复项和需排除项的情况下configurations中一共有127个组件，这127个组件默认需要导入容器，现在的重点变成了获取备选配置的方法getCandidateConfigurations(annotationMetadata, attributes)

         xxxxxxxxxx
         protected AutoConfigurationEntry getAutoConfigurationEntry(AnnotationMetadata annotationMetadata) {
             if (!isEnabled(annotationMetadata)) {
                 return EMPTY_ENTRY;
             }
             AnnotationAttributes attributes = getAttributes(annotationMetadata);
             List<String> configurations = getCandidateConfigurations(annotationMetadata, attributes);
             configurations = removeDuplicates(configurations);
             Set<String> exclusions = getExclusions(annotationMetadata, attributes);
             checkExcludedClasses(configurations, exclusions);
             configurations.removeAll(exclusions);
             configurations = getConfigurationClassFilter().filter(configurations);
             fireAutoConfigurationImportEvents(configurations, exclusions);
             return new AutoConfigurationEntry(configurations, exclusions);
         }
         

       • getCandidateConfigurations(annotationMetadata, attributes)方法解析:

         • SpringFactoriesLoader.loadFactoryNames( getSpringFactoriesLoaderFactoryClass(), getBeanClassLoader())方法使用Spring工厂加载器加载一些资源，重点是loadFactoryNames方法

           xxxxxxxxxx
           protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
               List<String> configurations = SpringFactoriesLoader.loadFactoryNames( getSpringFactoriesLoaderFactoryClass(),getBeanClassLoader());
               Assert.notEmpty(configurations,"No auto configuration classes found in META-INF/spring.factories. If you "+"are using a custom packaging, make sure that file is correct.");
               return configurations;
           }
           

         • loadFactoryNames方法中的重点是loadSpringFactories(classLoader)方法，利用loadSpringFactories方法加载得到一个Map集合，Map集合的value是一个List集合；这个Map集合中保存的就是所有的组件，只要看懂loadSpringFactories方法就能知道从哪里获取的所有组件

           xxxxxxxxxx
           public final class SpringFactoriesLoader {
               ...
               public static List<String> loadFactoryNames(Class<?> factoryType, @Nullable ClassLoader classLoader) {
                   String factoryTypeName = factoryType.getName();
                   return (List)loadSpringFactories(classLoader).getOrDefault( factoryTypeName, Collections.emptyList());
               }
           }
           

       • loadSpringFactories(classLoader)方法解析

         • classLoader.getResources("META-INF/spring.factories")：从META-INF/spring.factories位置加载一个文件，默认扫描当前系统中所有META-INF/spring.factories位置的文件，在引入的第三方jar包中，有些jar包有META-INF/spring.factories这个文件，如spring-boot、spring-boot-autoconfigure(最核心的)；有些包则没有这个文件

           在最核心的jar包spring-boot-autoconfigure-2.3.4.RELEASE.jar中的META-INF/spring.factories中第21行开始配置了@EnableAutoConfiguration注解由@Import(AutoConfigurationImportSelector.class)引入的全部127个自动配置组件，即该文件这127行写死了spring-boot一启动就要给容器加载的所有配置类，这些类也都在spring-boot-autoconfigure这个jar包下

         • 虽然127个场景的所有自动配置启动的时候默认全部加载，但是最终会按需分配，通过IoC容器的组件数量只有135个，包括我们自己配置的组件和其他组件，显然127个组件并未全部生效

         xxxxxxxxxx
         private static Map<String, List<String>> loadSpringFactories(@Nullable ClassLoader classLoader) {
             MultiValueMap<String, String> result = (MultiValueMap)cache.get(classLoader);
             if (result != null) {
                 return result;
             } else {
                 try {
                     Enumeration<URL> urls = classLoader != null ? classLoader.getResources("META-INF/spring.factories") : ClassLoader.getSystemResources("META-INF/spring.factories");
                     LinkedMultiValueMap result = new LinkedMultiValueMap();
                     while(urls.hasMoreElements()) {
                         URL url = (URL)urls.nextElement();
                         UrlResource resource = new UrlResource(url);
                         Properties properties = PropertiesLoaderUtils.loadProperties(resource);
                         Iterator var6 = properties.entrySet().iterator();
                         while(var6.hasNext()) {
                             Entry<?, ?> entry = (Entry)var6.next();
                             String factoryTypeName = ((String)entry.getKey()).trim();
                             String[] var9 = StringUtils.commaDelimitedListToStringArray((String)entry.getValue());
                             int var10 = var9.length;
                             for(int var11 = 0; var11 < var10; ++var11) {
                                 String factoryImplementationName = var9[var11];
                                 result.add(factoryTypeName, factoryImplementationName.trim());
                             }
                         }
                     }
                     cache.put(classLoader, result);
                     return result;
                 } catch (IOException var13) {
                     throw new IllegalArgumentException("Unable to load factories from location [META-INF/spring.factories]", var13);
                 }
             }
         }
         

   • 组件按需配置机制

     • 在对应127个组件的自动配置类中都有派生条件装配注解，如:

       • AopAutoConfiguration有@ConditionalOnClass(Advice.class),意思是当类路径中存在Advice这个类这个组件才会生效，也即只有导入了aop相关的包aspectj，对应的组件才会生效

       • BatchAutoConfiguration有@ConditionalOnClass(JobLauncher.class，DataSource.class)，也只有导入批处理的包，这个类下的组件才会生效

         xxxxxxxxxx
         @Configuration(proxyBeanMethods = false)
         @ConditionalOnClass({ JobLauncher.class, DataSource.class })
         @AutoConfigureAfter(HibernateJpaAutoConfiguration.class)
         @ConditionalOnBean(JobLauncher.class)
         @EnableConfigurationProperties(BatchProperties.class)
         @Import(BatchConfigurerConfiguration.class)
         public class BatchAutoConfiguration {
             ...
         }
         

       • 总结，派生条件装配注解的value发红对应组件就不会生效

     • 启动全部加载，最终按照条件装配规则按需配置

自动配置流程

1. 以AopAutoconfiguration分析自动配置功能(经确认AopAutoconfiguration确实在127个中)

   xxxxxxxxxx
   @Configuration(proxyBeanMethods = false)//表明这是一个配置类
   @ConditionalOnProperty(prefix = "spring.aop", name = "auto", havingValue = "true", matchIfMissing = true)//判断配置文件中是否有spring.aop.auto=true，有就生效,matchIfMissing = true意思是没有以上配置默认就是上述配置，满足上述条件允许注册AopAutoConfiguration类中的组件
   public class AopAutoConfiguration {
       
       //AopAutoConfiguration中两个类之一AspectJAutoProxyingConfiguration
       @Configuration(proxyBeanMethods = false)//配置类，非单实例
       @ConditionalOnClass(Advice.class)//判断整个应用中是否存在Advice这个类，Advice属于aspectj包下的Advice，由于没有导入aop场景，没有导入Aspectj的相关依赖，所以AspectJAutoProxyingConfiguration自动配置类下的所有组件都不生效
       static class AspectJAutoProxyingConfiguration {
           @Configuration(proxyBeanMethods = false)
           @EnableAspectJAutoProxy(proxyTargetClass = false)
           @ConditionalOnProperty(prefix = "spring.aop", name = "proxy-target-class", havingValue = "false",
                   matchIfMissing = false)
           static class JdkDynamicAutoProxyConfiguration {
   
           }
           @Configuration(proxyBeanMethods = false)
           @EnableAspectJAutoProxy(proxyTargetClass = true)
           @ConditionalOnProperty(prefix = "spring.aop", name = "proxy-target-class", havingValue = "true",
                   matchIfMissing = true)
           static class CglibAutoProxyConfiguration {
           }
       }
       
       //AopAutoConfiguration中的另一个类ClassProxyingConfiguration
       @Configuration(proxyBeanMethods = false)
       @ConditionalOnMissingClass("org.aspectj.weaver.Advice")//应用中没有Advice这个类就加载该类的所有组件，正好和上面的互斥
       @ConditionalOnProperty(prefix = "spring.aop", name = "proxy-target-class", havingValue = "true",matchIfMissing = true)//是否配置了spring.aop.proxy-target-class = true,没有配默认就是true，所以下列组件生效了
       static class ClassProxyingConfiguration {
           //以下是开启简单的AOP功能，在spring注解哪个课的aop原理有介绍
           ClassProxyingConfiguration(BeanFactory beanFactory) {
               if (beanFactory instanceof BeanDefinitionRegistry) {
                   BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
                   AopConfigUtils.registerAutoProxyCreatorIfNecessary(registry);
                   AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry);
               }
           }
       }
   }
   

2. 以CacheAutoconfiguration分析自动配置功能(经确认CacheAutoconfiguration确实在127个中)

   xxxxxxxxxx
   @Configuration(proxyBeanMethods = false)
   @ConditionalOnClass(CacheManager.class)//判断应用中有CacheManager缓存管理器这个类存在，该类在spring-context即spring的核心包下，是有的
   @ConditionalOnBean(CacheAspectSupport.class)//判断应用中是否有CacheAspectSupport这种类型的组件，经过查询容器中相关类型组件的数量，发现是0，说明容器中没有配置缓存支持的组件，以下所有配置全部失效，相当于整个缓存的所有配置都没有生效
   @ConditionalOnMissingBean(value = CacheManager.class, name = "cacheResolver")
   @EnableConfigurationProperties(CacheProperties.class)
   @AutoConfigureAfter({ CouchbaseDataAutoConfiguration.class,             HazelcastAutoConfiguration.class,HibernateJpaAutoConfiguration.class, RedisAutoConfiguration.class })
   @Import({ CacheConfigurationImportSelector.class, CacheManagerEntityManagerFactoryDependsOnPostProcessor.class })
   public class CacheAutoConfiguration {
       ...
   }
   

3. 以DispatcherServletAutoconfiguration分析自动配置功能(经确认确实在127个中)

   web下的servlet包下有很多自动配置类，不止DispatcherServletAutoconfiguration

   xxxxxxxxxx
   @AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE)//先不管，是说当前类的生效顺序，相当于指定当前类生效的优先级
   @Configuration(proxyBeanMethods = false)
   @ConditionalOnWebApplication(type = Type.SERVLET)//判断是否原生servlet的web应用，因为springboot2支持两种方式的web开发，一种响应式编程，一种原生servlet技术栈，当前是原生web开发
   @ConditionalOnClass(DispatcherServlet.class)//当前应用有没有DispatcherServlet这个类，导了springMVC就肯定有这个类，有所以生效
   @AutoConfigureAfter(ServletWebServerFactoryAutoConfiguration.class)//先不管，在括号内的自动配置类配置完后再来配置当前类，即想要配置当前类必须先配好web服务器先配好
   public class DispatcherServletAutoConfiguration {
   
       public static final String DEFAULT_DISPATCHER_SERVLET_BEAN_NAME = "dispatcherServlet";
   
       public static final String DEFAULT_DISPATCHER_SERVLET_REGISTRATION_BEAN_NAME = "dispatcherServletRegistration";
       
       //总类配置有效才有必要继续看DispatcherServletConfiguration
       @Configuration(proxyBeanMethods = false)
       @Conditional(DefaultDispatcherServletCondition.class)//有该条件才能生效，为什么生效后面再说
       @ConditionalOnClass(ServletRegistration.class)//应用中有没有ServletRegistration类型的组件，该组件导入tomcat核心包就有，所以有效
       @EnableConfigurationProperties(WebMvcProperties.class)//开启WebMvcProperties的配置绑定功能，把WebMvcProperties类的组件放在IoC容器中，经过测试，确实有一个
       protected static class DispatcherServletConfiguration {
           
           @Bean(name = DEFAULT_DISPATCHER_SERVLET_BEAN_NAME)//成功注册组件dispatcherServlet
           public DispatcherServlet dispatcherServlet(WebMvcProperties webMvcProperties) {
               DispatcherServlet dispatcherServlet = new DispatcherServlet();
               
               //这里为配置属性的代码
               ...
               
               return dispatcherServlet;
           }
   
           @Bean
           @ConditionalOnBean(MultipartResolver.class)//容器中如果有MultipartResolver类型的组件就生效，利用自己的一段代码判断生效的，在spring注解版中会讲
           @ConditionalOnMissingBean(name = DispatcherServlet.MULTIPART_RESOLVER_BEAN_NAME)//容器中没有名为multipartResolver的组件就生效，结合起来就是组件中有MultipartResolver类型的组件但是名字不为multipartResolver
           public MultipartResolver multipartResolver(MultipartResolver resolver) {
               //spring给@Bean标注的方法传入对象参数，这个参数会自动从容器中找并自动装配
               //很多用户不知道springMVC的底层原理，没有为MultipartResolver组件取名multipartResolver，spring也可以通过这个方法找到并返回给用户相应的名字不为multipartResolver的MultipartResolver组件，防止有些用户配置的文件上传解析器不符合规范，一返回到容器中，该组件的名字默认就变成了方法名multipartResolver，就符合规范了
               return resolver;
           }
   
       }
       ...
   }
   

4. HttpEncodingAutoconfiguration分析自动配置功能(经确认确实在127个中)

   请求参数和响应参数不乱码的原因就在于HttpEncodingAutoConfiguration

   xxxxxxxxxx
   @Configuration(proxyBeanMethods = false)
   @EnableConfigurationProperties(ServerProperties.class)//开启了ServerProperties类的配置绑定
   @ConditionalOnWebApplication(type = ConditionalOnWebApplication.Type.SERVLET)//判断是否为原生的servlet应用
   @ConditionalOnClass(CharacterEncodingFilter.class)//判断应用中是否有CharacterEncodingFilter这个组件，只要导入springMVC的jar包就肯定有这个filter
   @ConditionalOnProperty(prefix = "server.servlet.encoding", value = "enabled", matchIfMissing = true)//判断server.servlet.encoding=enabled是否成立，没有配置也默认是enabled，故以上判断均生效
   public class HttpEncodingAutoConfiguration {
   
       private final Encoding properties;
   
       public HttpEncodingAutoConfiguration(ServerProperties properties) {
           this.properties = properties.getServlet().getEncoding();
       }
   
       @Bean//这个characterEncodingFilter是springMVC解决编码问题的过滤器，请求和响应都可以设置
       @ConditionalOnMissingBean//不写属性表示当前组件容器中没有就生效，有就不生效，这里也显示出springBoot的设计思想，SpringBoot默认在底层配置好所有的组件，但是如果用户配置了就以用户的优先
       public CharacterEncodingFilter characterEncodingFilter() {
           CharacterEncodingFilter filter = new OrderedCharacterEncodingFilter();
           filter.setEncoding(this.properties.getCharset().name());
           filter.setForceRequestEncoding(this.properties.shouldForce(Encoding.Type.REQUEST));
           filter.setForceResponseEncoding(this.properties.shouldForce(Encoding.Type.RESPONSE));
           return filter;
       }
       ...
   }
   

总结

1. SpringBoot先加载所有的自动配置类 xxxxxAutoConfiguration

2. 每个自动配置类按照条件进行生效，默认都会绑定配置文件指定的值。（xxxxProperties里面读取，xxxProperties和配置文件进行了绑定，在xxxxxAutoConfiguration中会大量看到@EnableConfigurationProperties(XxxxProperties.class)注解，而配置文件中各种配置代表什么意思官方文档中的Application Properties都可以查到，学好技术改配置比如使用redis就一句话的事）

3. 生效的配置类会给容器中装配很多组件

4. 只要容器中有这些组件，相当于这些功能就有了

5. 只要用户有自己配置的，就以用户的优先，即定制化配置:

   • 办法一：用户直接自己用@Bean替换底层的组件

   • 办法二：用户查看目标组件获取的配置文件的对应值去属性配置文件自己修改即可，比如上述例子中的字符编码格式:

     • 点开对应的CharacterEncodingFilter类查看@ConditionalOnProperty注解的前缀prefix="server.servlet.encoding"

     • 在HttpEncodingAutoConfiguration中观察到通过this.properties.getCharset()方法获取属性值

     • 即属性配置文件的key对应为server.servlet.encoding.charset=GBK

6. 自动配置原理全流程：

   • xxxxxAutoConfiguration加载自动配置类 ---> 根据条件注册组件 ---> 组件从xxxxProperties里面拿值 ----> xxxxProperties绑定的就是application.properties里面的值

最佳实践

SpringBoot开发技巧

1. 引入场景依赖

   • 比如开发缓存、消息队列等首先看SpringBoot或者第三方有没有开发相关的场景依赖，第三方技术提供的starter和Spring官方提供的starter列表：官方文档(Using Spring Boot--->Starters)

2. 查看自动配置了哪些组件（选做，因为比较偏底层原理，关心源码比较有用）

   • 自己分析，引入场景对应的自动配置一般都会生效，但是逐行分析比较麻烦

   • 配置文件中添加debug=true开启自动配置报告，会在控制台输出哪些配置类生效，哪些未生效，未生效会提示Did not match：不生效的原因

     • 控制台的Negative matches下展示未生效的组件列表

     • 控制台的Positive matches下展示生效的组件列表

3. 修改配置项

   • 参考官方文档的Application Properties：官方文档

   • 自己到XxxxProperties查看绑定了配置文件的哪些配置然后自己分析更改

     ~示例修改spring.banner；banner是springboot启动时的图标，可以使用本地的图片替换，可以通过指定spring.banner.image.location的值，默认值是找classpath:banner.gif或者jpg或png；可以直接把图片的名字改成banner，也可以指定spring.banner.image.location=图片名.jpg;

   • 自己添加或者替换组件

     • 通过@Bean、@Component...，因为用户有的以用户优先

   • 自定义器 XXXXXCustomizer

     • 以后会讲

   • ...

Lombok简化开发

1. 使用Lombok的步骤

   • 步骤一：添加Lomback依赖

   • 步骤二：IDEA中File->Settings->Plugins，搜索安装Lombok插件

   • 步骤三：使用Lombok

     • 通过注解@Data标注类在编译阶段生成setter/getter方法

     • 通过注解@ToString标注类在编译阶段生成toString方法

     • 通过注解@AllArgsConstructor标注类在编译阶段生成所有属性的有参构造器

     • 通过注解@NoArgsConstructor标注类在编译阶段生成无参构造器

     • 通过注解@EqualsAndHashCode标注类在编译阶段生成Equals和HashCode方法

     • 通过注解@Slf4j标注类自动给类添加log属性用来记录日志以简化日志开发

2. SpringBoot2默认管理的lombok版本1.18.12，需要用户自己引入依赖，Lombok的作用是在程序编译阶段自动生成程序的setter/getter方法、toString方法、构造方法、Equals和HashCode方法

   ~Lombok依赖

   xxxxxxxxxx
   <dependency>     
       <groupId>org.projectlombok</groupId>     
       <artifactId>lombok</artifactId>
   </dependency>
   

3. 用法实例

   xxxxxxxxxx
   @Slf4j
   @Data
   @ToString
   @NoArgsConstructor
   @AllArgsConstructor
   @EqualsAndHashCode
   public class User {
       private String name;
       private Integer age;
       private Pet pet;
   
       public User(String name, Integer age) {
           log.info("有参构造方法执行了!");
           this.name = name;
           this.age = age;
       }
   }
   

spring-boot-devtools

1. 使用spring-boot-devtools的步骤

   • 步骤一：官方文档-->Using Spring Boot-->Developer Tools-->拷贝依赖信息

     ~dev-tools依赖

     xxxxxxxxxx
     <dependencies>
         <dependency>
             <groupId>org.springframework.boot</groupId>
             <artifactId>spring-boot-devtools</artifactId>
             <optional>true</optional>
         </dependency>
     </dependencies>
     

2. spring-boot-devtools的作用是热更新，修改代码或者修改web页面后只需要按Ctrl+F9(作用是让项目重新编译一遍，编译完毕devtools就能自动帮助用户重新加载)，页面就能实时生效；不需要再重启服务器。devtools的实质是自动重启服务器

   • 注意：如果没有修改任何资源，ctrl+f9不会生效

3. 需要使用真正的热更新Reload需要使用付费的插件JRebel

Spring Initailizr

1. Spring Initailizr的使用

   • Spring Initailizr是创建Spring Boot项目初始化向导，创建工程的时候不选择maven或者空工程，直接创建Spring Initailizr工程

2. Spring Initailizr的作用

   • 在工程创建过程中就可以勾选想要引入的场景，想要使用的数据库，Mybatis，SpringBoot的版本等等

   • 创建工程后会自动生成pom.xml的场景启动器相关配置并且引入junit和打包插件

   • 自动创建全局配置文件、static目录(写所有的静态资源，即CSS、JS文件)、templates目录(写所有的视图页面)

   • 自动创建主程序类(以工程名+Application构成)

      

配置文件

yaml配置文件

SpringBoot兼容两种配置文件格式，properties文件和yaml，注意yaml的后缀可以是.yaml，也可以是.yml;SpringBoot中需要起名application.yml,如果两种类型的文件都有，两个文件都会生效，且同名配置以properties文件优先加载

YAML 是 "YAML Ain't Markup Language"（YAML 不是一种标记语言）的递归缩写。在开发的这种语言时，YAML 的意思其实是："Yet Another Markup Language"（仍是一种标记语言），标记语言表示文件是用标签写的

YAML非常适合用来做以数据为中心的配置文件，即存储配置数据而不是定义一些行为动作，spring的配置首选yaml，优点就是能够清晰的看见属性配置的从属关系

基本语法

1. 配置数据的格式

   • key: value；[所有冒号和value之间有空格，且key和value严格区分大小写]

2. 使用缩进表示层级关系

   [XMl通过标签表示层级关系，而YAML通过缩进表示层级关系，缩进一般不允许使用tab，只允许使用空格，但是IDEA中可以使用tab空格数不重要，但是要保证相同层级的元素要对齐，不同层级的空格数可以不一样]

3. '#'表示注释

4. 字符串无需加引号，默认行为与加单引号相同，可以按需加单双引号

   • 单引号会转义字符串中的'转义字符'，双引号不会转义字符串中的'转义字符'

数据类型

1. 字面量：字面量是单个的、不可再分的值。对应的java类型有date、boolean、string、number、null

   xxxxxxxxxx
   key: value
   

2. 对象：表示对象有两种写法，对应的java对象有map、hash、set[set集合不是只有value吗，不应该在数组的表示方法中吗]、object

   xxxxxxxxxx
   #行内写法： 注意大括号中的冒号要有空格，不然展示的是字符串
   k: {k1:v1,k2:v2,k3:v3}
   
   #或
   
   #对象表示法,注意表示的对象如果作为数组或集合的元素可以用'-'代替'k:'
   k: 
     k1: v1
     k2: v2
     k3: v3
   

3. 数组以及以数组为基础的集合：一组按次序排列的值。对应的java对象array、list、queue

   xxxxxxxxxx
   #行内写法：  
   k: [v1,v2,v3]
   
   #或者
   
   #普通写法:一个'-'代表一个元素，'-'和值之间用空格隔开
   k:
    - v1
    - v2
    - v3
   

    

yaml实例

1. 目标类

   xxxxxxxxxx
   @ConfigurationProperties(prefix = "person")
   @Component
   @ToString
   @Data
   public class Person {
       private String userName;
       private Boolean boss;
       private Date birth;
       private Integer age;
       private Pet pet;
       private String[] interests;
       private List<String> animal;
       private Map<String, Object> score;
       private Set<Double> salarys;
       private Map<String, List<Pet>> allPets;
   }
   
   @ToString
   @Data
   public class Pet {
       private String name;
       private Double weight;
   }
   

2. application.yml对应配置

   xxxxxxxxxx
   person:
     userName: "zhangsan \n 李四"
     #单引号会将其中的特殊字符转换成普通字符，与不加单引号双引号的默认行为相同
     #双引号不会将其中的特殊字符转换成普通字符，如"zhangsan \n 李四"整体作为字符串输出到控制台，换行符仍然生效
     #即单引号会转义字符串中的'转义字符'，双引号不会转义字符串中的'转义字符'
     boss: true
     birth: 2019/12/9
     age: 19
     #interests: [抽烟,喝酒,烫头]
     interests:
       - 抽烟
       - 喝酒
       - 烫头
     animal: [阿猫,阿狗]
     #score:
       #English: 80
       #Math: 90
     score: {english: 80,math: 90}
     salarys:
       - 9999.98
       - 9999.99
     pet:
       name: 阿狗
       weight: 99.99
     allPets:
       sick:
         - {name: 阿狗,weight: 99.99}
         - name: 阿猫
           weight: 88.88
         - name: 阿虫
           weight: 77.77
       health:
         - {name: 阿花,weight: 199.99}
         - {name: 阿明,weight: 199.99}
   

配置注解处理器

注解处理器的作用是针对用户自定义类添加了@ConfigurationProperties注解后在属性配置文件中提供提示功能

~引入Configuration the Annotation Processer依赖

xxxxxxxxxx
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-configuration-processor</artifactId>
    <optional>true</optional>
</dependency>

~排除Configuration the Annotation Processer依赖的插件打包行为

xxxxxxxxxx
<!-- 下面插件作用是工程打包时，不将spring-boot-configuration-processor打进包内，让其只在编码的时候有用 -->
<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
            <configuration>
                <excludes>
                    <exclude>
                        <groupId>org.springframework.boot</groupId>
                        <artifactId>spring-boot-configuration-processor</artifactId>
                    </exclude>
                </excludes>
            </configuration>
        </plugin>
    </plugins>
</build>

SpringBoot-Web开发

Web开发的官方文档位于Spring Boot Features--->Developing Web Application

Web开发简介

SpringMVC自动配置概览

1. SpringBoot-Web开发为SpringMVC自动配置的组件列表

   [没有说全，只说了大部分内容]

   • Inclusion of ContentNegotiatingViewResolver and BeanNameViewResolver beans.

     • 内容协商视图解析器和BeanName视图解析器

   • Support for serving static resources, including support for WebJars (covered later in this document)).

     • 静态资源的访问组件（包括webjars）

   • Automatic registration of Converter, GenericConverter, and Formatter beans.

     • 自动注册所有的转换器和格式化器【用来类型转换的转换器】

   • Support for HttpMessageConverters (covered later in this document).

     • 支持 HttpMessageConverters

       【后来配合内容协商理解原理】

   • Automatic registration of MessageCodesResolver (covered later in this document).

     • 自动注册 MessageCodesResolver

       【国际化用，一般用不到，因为一般针对国内外用户做两套网站，因为语言和文化的区别】

   • Static index.html support.

     • 静态index.html 页支持

       【将欢迎页放到指定位置会自动支持欢迎页机制】

   • Custom Favicon support (covered later in this document).

     • 自定义 Favicon

   • Automatic use of a ConfigurableWebBindingInitializer bean (covered later in this document).

     • 自动使用 ConfigurableWebBindingInitializer

       【DataBinder负责将请求数据绑定到JavaBean上，如WebDataBinder】

     • 没有喜欢的也可以自定义数据绑定器

2. SpringBoot自定义组件的三种方案

   If you want to keep those Spring Boot MVC customizations and make more MVC customizations (interceptors, formatters, view controllers, and other features), you can add your own @Configuration class of type WebMvcConfigurer but without @EnableWebMvc.

   不用@EnableWebMvc注解。使用 @Configuration + WebMvcConfigurer 自定义规则

   If you want to provide custom instances of RequestMappingHandlerMapping, RequestMappingHandlerAdapter, or ExceptionHandlerExceptionResolver, and still keep the Spring Boot MVC customizations, you can declare a bean of type WebMvcRegistrations and use it to provide custom instances of those components.

   声明 WebMvcRegistrations 改变默认底层组件

   If you want to take complete control of Spring MVC, you can add your own @Configuration annotated with @EnableWebMvc, or alternatively add your own @Configuration-annotated DelegatingWebMvcConfiguration as described in the Javadoc of @EnableWebMvc.

   使用 @EnableWebMvc+@Configuration+DelegatingWebMvcConfiguration 全面接管SpringMVC

静态资源规则与定制化

静态资源指图片、视频、JS文件、CSS文件等等

静态资源访问

1. 静态资源目录

   • 只要以下目录放在类路径下[resources目录下]都可以作为静态资源目录

     【 /static or /public or /resources or /META-INF/resources】

2. 静态资源的请求路径

   • 当前项目根路径即/ + 带后缀的静态资源名 【如：http://localhost:8080/1.png】

3. 静态资源的访问前缀

   • 静态资源的请求路径默认无前缀

   • 可以通过spring.mvc.static-path-pattern属性配置静态资源访问前缀，设置前缀后的请求路径为:

     当前项目根路径即/ +spring.mvc.static-path-pattern+ 带后缀的静态资源名【如：http://localhost:8080/res/1.png】

     xxxxxxxxxx
     spring:
       mvc:
         static-path-pattern: /res/**
     

4. 改变默认的静态资源路径

   • 通过spring.web.resources.static-locations属性指定新的静态资源目录，指定的新目录可以是一个数组，即可以配置多个静态目录，此时默认静态资源目录除 /META-INF/resources外的确全部失效

     xxxxxxxxxx
     spring:
       web:
         resources:
           static-locations: [classpath:/app1]
     

5. WebJars

   作用是把一些前端资源文件以jar包的方式作为maven依赖导入应用

   • 把常见的一些Bootstrap、JQuery、CSS等资源文件弄成了jar包，实际jar包解压之后里面还是原版资源文件，jar包可以作为依赖导入maven

     ~导入jquery的依赖

     xxxxxxxxxx
     <dependency>
         <groupId>org.webjars</groupId>
         <artifactId>jquery</artifactId>
         <version>3.5.1</version>
     </dependency>
     

   • WebJars官网：https://www.webjars.org/

   • 访问地址：http://localhost:8080/webjars/jquery/3.5.1/dist/jquery.js 【项目根路径'/'后面地址webjars/jquery/3.5.1/dist/jquery.js是按照对应依赖jar包里面的类路径写的】

欢迎页支持

SpringBoot支持两种欢迎页设置方式

1. 静态资源目录下的index.html

   • 当设置了访问前缀，所有的欢迎页都会失效；未设置访问前缀，所有静态资源目录下的欢迎页均有效

     xxxxxxxxxx
     spring:
       #mvc:
       #  static-path-pattern: /res/**  #这个会导致所有静态资源目录下index.html的欢迎页功能失效
       web:
         resources:
           static-locations: [classpath:/app1]
     

2. 使用Controller处理"/"跳转index.html

   • 这个暂时还没说

自定义Favicon

Favicon的作用是设置网页标签上的小图标，访问该应用的任何请求都会展示该小图标，小图标是浏览器显示在Title前面的图标

1. 设置方式

   • 将目标小图标命名成favicon.ico放在静态资源目录下即可

     【注意设置了访问前缀会导致Favicon功能失效，添加了静态资源应该clear和package一下，避免资源没有打包到target】

     xxxxxxxxxx
     spring:
       #mvc:
       #  static-path-pattern: /res/**  #这个设置会导致Favicon功能失效
     

静态资源配置原理

1. SpringBoot启动默认加载自动配置类xxxAutoConfiguration类，相关的xxxAutoConfiguration有：

   • DispatcherServlertConfiguration【配置DispatcherServlet规则的】

   • HttpEncodingAutoConfiguration【配置编解码的】

   • MultipartAutoConfiguration【配置文件上传的】

   • ServletWebServerAutoConfiguration【配置服务器的】

   • WebMvcAutoConfiguration【这个是SpringMVC的自动配置，SpringMVC的功能大多集中在这个类中】

2. WebMvcAutoConfiguration源码解析

   • 重点一：配置类组件WebMvcAutoConfigurationAdapter中进行配置绑定的两个类

     • WebMvcProperties：绑定spring.mvc前缀的配置属性

     • ResourceProperties：绑定spring.spring.resources前缀的配置属性

   • 重点二：WebMvcAutoConfiguration配置类给容器中配置的组件

     • ResourceProperties resourceProperties：获取和spring.resources配置绑定所有值的对象

     • WebMvcProperties mvcProperties：获取和spring.mvc配置绑定所有值的对象

     • ListableBeanFactory beanFactory:Spring的beanFactory(bean工厂)，即IoC容器 【以下ObjectProvider<Xxx>表示找到容器中的所有Xxx组件】

     • ObjectProvider<HttpMessageConverters>:找到所有的HttpMessageConverters

     • ObjectProvider<ResourceHandlerRegistrationCustomizer>:找到资源处理器的自定义器

     • ObjectProvider<DispatcherServletPath>:找DispatcherServlet能处理的路径

     • ObjectProvider<ServletRegistrationBean<?>>:找到所有给应用注册Servlet、Filter、Listener的组件

   • 重点三：静态资源的默认处理规则

     • WebJars对应静态资源的相关规则

       • 如果有/webjars/**请求，去类路径下找/META-INF/resources/webjars/，且相应静态资源应用缓存策略，缓存时间由spring.resources.cache.period配置属性控制

     • 静态资源路径的相关配置规则

       • 通过spring.mvc.static-path-pattern属性获取静态资源目录是否有前缀，没配置也有默认值staticPathPattern=/**,即匹配所有请求，通过this.resourceProperties.getStaticLocations()去找静态资源，staticLocations是一个字符串数组，有四个字符串默认值:被定义成常量的字符串数组{ "classpath:/META-INF/resources/","classpath:/resources/", "classpath:/static/", "classpath:/public/" }，即静态资源默认的四个位置，且这里的静态资源也有缓存策略

   • 重点四：欢迎页处理规则

     • 通过spring.mvc.static-path-pattern属性(指定静态资源请求前缀，默认是没有前置，即/**)创建welcomePageHandlerMapping

     • 如果欢迎页存在且静态资源请求路径没有前缀，则重定向到静态资源目录的index.html，所以有自定义静态资源请求前缀欢迎页就找不到了，在创建对象welcomePageHandlerMapping的第一个if中写死了

     • 否则如果欢迎页存在，但是staticPathPattern不为/**，直接设置viewName为index转到Controller看是否存在控制器方法能处理"/index"请求

   【WebMvcAutoConfiguration的源码逐行解析】

   xxxxxxxxxx
   @Configuration(proxyBeanMethods = false)
   @ConditionalOnWebApplication(type = Type.SERVLET)//判断是否原生servlet的web应用，是就生效
   @ConditionalOnClass({ Servlet.class, DispatcherServlet.class, WebMvcConfigurer.class })//应用中有Servlet类、DispatcherServlet类、WebMvcConfigurer类就生效，这些是导了spring-webmvc就一定会有的
   @ConditionalOnMissingBean(WebMvcConfigurationSupport.class)//容器中没有WebMvcConfigurationSupport这个组件就生效，只要有这个组件下面这个类的所有配置都不生效，在这儿规定了后面介绍的全面接管SpringMVC，全面的定制SpringMVC，只要用户配置了，自动配置SpringMVC就不生效
   @AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE + 10)
   @AutoConfigureAfter({ DispatcherServletAutoConfiguration.class, TaskExecutionAutoConfiguration.class,
           ValidationAutoConfiguration.class })
   public class WebMvcAutoConfiguration {
       ...
   
       @Bean//OrderedHiddenHttpMethodFilter是HiddenHttpMethodFilter的子类,SpringMVC兼容Rest风格的过滤器组件，接收前端发送的put、delete请求,SpringBoot默认就配置了HiddenHttpMethodFilter组件
       @ConditionalOnMissingBean(HiddenHttpMethodFilter.class)
       @ConditionalOnProperty(prefix = "spring.mvc.hiddenmethod.filter", name = "enabled", matchIfMissing = false)//如果spring.mvc.hiddenmethod.filter.name属性为true就开启HiddenHttpMethodFilter组件的功能，默认值为false，所以在表单发送请求的前提下还要在全局配置文件中配置spring.mvc.hiddenmethod.filter.name=true
       public OrderedHiddenHttpMethodFilter hiddenHttpMethodFilter() {
           return new OrderedHiddenHttpMethodFilter();
       }
   
       @Bean//OrderedFormContentFilter表单内容的过滤器
       @ConditionalOnMissingBean(FormContentFilter.class)
       @ConditionalOnProperty(prefix = "spring.mvc.formcontent.filter", name = "enabled", matchIfMissing = true)
       public OrderedFormContentFilter formContentFilter() {
           return new OrderedFormContentFilter();
       }
   
       ...
   
           
       //重点一
       @Configuration(proxyBeanMethods = false)//配置类WebMvcAutoConfigurationAdapter是一个WebMvcConfigurer组件
       @Import(EnableWebMvcConfiguration.class)
       @EnableConfigurationProperties({ WebMvcProperties.class, ResourceProperties.class })//这行代码表示配置类与WebMvcProperties、ResourceProperties直接进行绑定，简介与配置文件中的配置数据进行绑定
       //WebMvcProperties：该类上@Configurationproperties(prefix="spring.mvc")表明其跟配置文件的spring.mvc前缀存在配置绑定关系
       //ResourceProperties:该类上@Configurationproperties(prefix="spring.resources")表明其跟配置文件的spring.resources前缀存在配置绑定关系
       @Order(0)
       public static class WebMvcAutoConfigurationAdapter implements WebMvcConfigurer {
   
           ...属性
   
               
           //重点二
           //这个配置类只有一个有参构造器，仅有一个有参构造器的所有参数都会从IoC容器中确定,以下是从容器中确定的参数
           //ResourceProperties resourceProperties：获取和spring.resources配置绑定所有值的对象
           //WebMvcProperties mvcProperties：获取和spring.mvc配置绑定所有值的对象
           //ListableBeanFactory beanFactory:Spring的beanFactory(bean工厂)，即IoC容器
           //以下ObjectProvider<Xxx>表示找到容器中的所有Xxx组件
           //ObjectProvider<HttpMessageConverters>:找到所有的HttpMessageConverters
           //ObjectProvider<ResourceHandlerRegistrationCustomizer>:找到资源处理器的自定义器
           //ObjectProvider<DispatcherServletPath>:找DispatcherServlet能处理的路径
           //ObjectProvider<ServletRegistrationBean<?>>:找到所有给应用注册Servlet、Filter、Listener的组件
           public WebMvcAutoConfigurationAdapter(ResourceProperties resourceProperties, WebMvcProperties mvcProperties,
                   ListableBeanFactory beanFactory, ObjectProvider<HttpMessageConverters> messageConvertersProvider,
                   ObjectProvider<ResourceHandlerRegistrationCustomizer> resourceHandlerRegistrationCustomizerProvider,
                   ObjectProvider<DispatcherServletPath> dispatcherServletPath,
                   ObjectProvider<ServletRegistrationBean<?>> servletRegistrations) {
               ...给属性赋值
           }
   
           ...无关代码
   
           @Bean//配置视图资源解析器InternalResourceViewResolver，配置条件容器中没有就配置，用户配置了就不自动配置了
           @ConditionalOnMissingBean
           public InternalResourceViewResolver defaultViewResolver() {
               InternalResourceViewResolver resolver = new InternalResourceViewResolver();
               resolver.setPrefix(this.mvcProperties.getView().getPrefix());
               resolver.setSuffix(this.mvcProperties.getView().getSuffix());
               return resolver;
           }
   
           ...无关代码
               
           @Bean//添加国际化支持组件localeResolver()
           @ConditionalOnMissingBean
           @ConditionalOnProperty(prefix = "spring.mvc", name = "locale")
           public LocaleResolver localeResolver() {
               if (this.mvcProperties.getLocaleResolver() == WebMvcProperties.LocaleResolver.FIXED) {
                   return new FixedLocaleResolver(this.mvcProperties.getLocale());
               }
               AcceptHeaderLocaleResolver localeResolver = new AcceptHeaderLocaleResolver();
               localeResolver.setDefaultLocale(this.mvcProperties.getLocale());
               return localeResolver;
           }
   
           ...无关代码
               
           @Override//格式化器，一般用来格式化货币日期
           public void addFormatters(FormatterRegistry registry) {
               ApplicationConversionService.addBeans(registry, this.beanFactory);
           }
   
           
           //重点三(*****核心在此处)
           @Override//添加资源处理器，所有的资源处理默认规则都在这
           public void addResourceHandlers(ResourceHandlerRegistry registry) {
               if (!this.resourceProperties.isAddMappings()) {//ResourceProperties中的addMapping属性，对应配置文件中的spring.resources.add-mapping属性，可选值true和false，默认是true。如果配置成false，就会执行日志输出，下面所有的配置都不生效，下面的配置是:静态资源的规则配置，可以通过设置spring.resources.add-mapping为false禁用所有静态资源的路径映射，所有的静态资源都无法访问
                   logger.debug("Default resource handling disabled");//日志信息是静态资源已经被禁用掉了
                   return;
               }
               Duration cachePeriod = this.resourceProperties.getCache().getPeriod();//通过spring.resources.cache.period获取缓存策略，cache.period是缓存资源刷新时间，从ResourceProperties中可以看出以秒为单位，意为所有的静态资源浏览器默认可以存多少秒
               CacheControl cacheControl = this.resourceProperties.getCache().getCachecontrol().toHttpCacheControl();
               
               //WebJars的相关规则
               //开始注册webJars下的所有请求，如果有/webjars/**请求，去类路径下找/META-INF/resources/webjars/，且相应静态资源应用缓存策略，缓存时间由spring.resources.cache.period配置属性控制
               if (!registry.hasMappingForPattern("/webjars/**")) {
              customizeResourceHandlerRegistration(registry.addResourceHandler("/webjars/**")
                           .addResourceLocations("classpath:/META-INF/resources/webjars/")
                   .setCachePeriod(getSeconds(cachePeriod)).setCacheControl(cacheControl));
               //所有webjars请求都去类路径下找/META-INF/resources/webjars/，直接从External Libraries下找吗？在target下的/META-INF/resources/下没看见对应资源，但是还是能够访问，且该静态资源能够在缓存中按照缓存策略设置的时间缓存一段时间，在响应头的Cache-Control能够看到缓存的最大时间
               }
               
               //静态资源路径的相关配置规则
               String staticPathPattern = this.mvcProperties.getStaticPathPattern();//通过spring.mvc.static-path-pattern属性获取静态资源目录是否有前缀，没配置也有默认值staticPathPattern=/**,即匹配所有请求
               if (!registry.hasMappingForPattern(staticPathPattern)) {
                   customizeResourceHandlerRegistration(registry.addResourceHandler(staticPathPattern)
                           .addResourceLocations(getResourceLocations(this.resourceProperties.getStaticLocations()))
                           .setCachePeriod(getSeconds(cachePeriod)).setCacheControl(cacheControl));
               //所有请求都去指定的位置this.resourceProperties.getStaticLocations()去找静态资源，staticLocations是一个字符串数组，有四个字符串默认值:被定义成常量的字符串数组{ "classpath:/META-INF/resources/","classpath:/resources/", "classpath:/static/", "classpath:/public/" }，即静态资源默认的四个位置，且这里的静态资源也有缓存策略
               }
           }
           ...无关代码
       }
   
       @Configuration(proxyBeanMethods = false)//配置类
       public static class EnableWebMvcConfiguration extends DelegatingWebMvcConfiguration implements ResourceLoaderAware {
           
           ...无关代码
           
               
           //重点四
           @Bean//欢迎页的配置规则
           //HandleMapping:处理器映射，是SpringMVC中的一个核心组件，里面保存了每一个Handler能处理哪些请求，找到了就利用反射机制调用对应的方法,WelcomePageHandlerMapping中就存放了谁来处理欢迎页的请求映射规则
           public WelcomePageHandlerMapping welcomePageHandlerMapping(ApplicationContext applicationContext,
                   FormattingConversionService mvcConversionService, ResourceUrlProvider mvcResourceUrlProvider) {
               //通过spring.mvc.static-path-pattern属性(指定静态资源请求前缀，默认是没有前置，即/**)创建welcomePageHandlerMapping，重点是创建welcomePageHandlerMapping对象时配置了静态资源请求前缀无法访问欢迎页面的问题
               WelcomePageHandlerMapping welcomePageHandlerMapping = new WelcomePageHandlerMapping(
                       new TemplateAvailabilityProviders(applicationContext), applicationContext, getWelcomePage(),
                       this.mvcProperties.getStaticPathPattern());
       welcomePageHandlerMapping.setInterceptors(getInterceptors(mvcConversionService, mvcResourceUrlProvider));
               welcomePageHandlerMapping.setCorsConfigurations(getCorsConfigurations());
               return welcomePageHandlerMapping;
           }
           ...无关代码
       }
       //定义接口
       interface ResourceHandlerRegistrationCustomizer {
           void customize(ResourceHandlerRegistration registration);
       }
       //定义类
       static class ResourceChainResourceHandlerRegistrationCustomizer implements ResourceHandlerRegistrationCustomizer {
           ...无关代码
       }
       //定义类
       static class OptionalPathExtensionContentNegotiationStrategy implements ContentNegotiationStrategy {
           ...无关代码
   }
   

   【WelcomePageHandlerMapping欢迎页处理映射器构造方法的代码逐行解析】

   xxxxxxxxxx
   WelcomePageHandlerMapping(TemplateAvailabilityProviders templateAvailabilityProviders,
               ApplicationContext applicationContext, Optional<Resource> welcomePage, String staticPathPattern) {
       //如果欢迎页存在且静态资源请求路径没有前缀，则重定向到静态资源目录的index.html，所以有自定义静态资源请求前缀欢迎页就找不到了，在第一个if中写死了
       if (welcomePage.isPresent() && "/**".equals(staticPathPattern)) {
           //所以要使用欢迎页功能不能添加静态资源请求前缀，staticPathPattern必须是/**
           logger.info("Adding welcome page: " + welcomePage.get());
           setRootViewName("forward:index.html");
       }
       else if (welcomeTemplateExists(templateAvailabilityProviders, applicationContext)) {
           logger.info("Adding welcome page template: index");
           //否则如果欢迎页存在，但是staticPathPattern不为/**，直接设置viewName为index转到Controller看谁能不能处理"/index"请求
           setRootViewName("index");
       }
   }
   

    

请求参数处理

Rest风格请求映射原理

1. @RequestMapping的派生注解

   • @GetMapping【相当于@RequestMapping(value = "/user",method = RequestMethod.GET)】

   • @PostMapping【~@RequestMapping(value = "/user",method = RequestMethod.POST)】

   • @PutMapping【~@RequestMapping(value = "/user",method = RequestMethod.PUT)】

   • @DeleteMapping【~@RequestMapping(value = "/user",method = RequestMethod.DELETE)】

2. Rest风格支持【使用同一请求路径不同的HTTP请求方式动词来区分对资源的操作】

   • 以前：[/getUser 获取用户]，[/deleteUser 删除用户]，[/editUser 修改用户]，[/saveUser保存用户]

   • 现在：/user [GET-获取用户]，[DELETE-删除用户]，[PUT-修改用户]，[POST-保存用户]

   • Rest风格支持核心的核心Filter组件：HiddenHttpMethodFilter

     • SpringBoot默认就配置了HiddenHttpMethodFilter组件，其实是其子类OrderedHiddenHttpMethodFilter

3. HiddenHttpMethodFilter组件的用法

   • 步骤一：通过前端页面form表单发送post请求，设置隐藏域类型的_method参数为put、delete发送PUT或DELETE请求，GET请求和POST请求正常发，实现前端Rest风格请求的发送准备

     xxxxxxxxxx
     <form action="/user" method="get">
         <input value="REST-GET提交" type="submit" />
     </form>
     
     <form action="/user" method="post">
         <input value="REST-POST提交" type="submit" />
     </form>
     
     <form action="/user" method="post">
         <input name="_method" type="hidden" value="DELETE"/>
         <input value="REST-DELETE 提交" type="submit"/>
     </form>
     
     <form action="/user" method="post">
         <input name="_method" type="hidden" value="PUT" />
         <input value="REST-PUT提交"type="submit" />
     </form>
     

   • 步骤二：通过在全局配置文件中配置spring.mvc.hiddenmethod.filter.name=true开启页面表单的隐藏请求方式过滤器组件的功能

     xxxxxxxxxx
     spring:
       mvc:
         hiddenmethod:
           filter:
             enabled: true   #开启页面表单的Rest功能
     

   • 步骤三：编写控制器方法处理Rest风格请求映射

     xxxxxxxxxx
     @GetMapping("/user")
     //@RequestMapping(value = "/user",method = RequestMethod.GET)
     public String getUser(){
         return "GET-张三";
     }
     
     @PostMapping("/user")
     //@RequestMapping(value = "/user",method = RequestMethod.POST)
     public String saveUser(){
         return "POST-张三";
     }
     
     @PutMapping("/user")
     //@RequestMapping(value = "/user",method = RequestMethod.PUT)
     public String putUser(){
         return "PUT-张三";
     }
     
     @DeleteMapping("/user")
     //@RequestMapping(value = "/user",method = RequestMethod.DELETE)
     public String deleteUser(){
         return "DELETE-张三";
     }
     

4. form表单提交使用REST风格的原理

   • 发送put和delete请求表单以post方式提交并添加请求参数'_method',即开启页面表单的Rest功能

   • 请求被服务器捕获并被HiddenHttpMethodFilter拦截

     • 请求方式是否为post且请求没有错误和异常

       • 获取表单请求参数_method的属性值

         • 如果属性值不为空串或者null则全部转换为大写字母

         • 判断_method的属性值是否为PUT、DELETE、PATCH三者之一

           • 是就创建原生请求对象的包装类，将method的属性值赋值给包装类自己的method属性中，通过重写getMethod方法将获取请求方式的值指向method的属性值

     • 如果请求方式不为post直接放行原生请求，如果是post就放行请求的包装类

   • 相关源码

   【配置spring.mvc.hiddenmethod.filter.name=true的源码】

   xxxxxxxxxx
   public class WebMvcAutoConfiguration {
       ...
       @Bean//OrderedHiddenHttpMethodFilter是HiddenHttpMethodFilter的子类,SpringMVC兼容Rest风格的过滤器组件，接收前端发送的put、delete请求,SpringBoot默认就配置了HiddenHttpMethodFilter组件
       @ConditionalOnMissingBean(HiddenHttpMethodFilter.class)
       @ConditionalOnProperty(prefix = "spring.mvc.hiddenmethod.filter", name = "enabled", matchIfMissing = false)//如果spring.mvc.hiddenmethod.filter.name属性为true就开启HiddenHttpMethodFilter组件的功能，默认值为false，所以在表单发送请求的前提下还要在全局配置文件中配置spring.mvc.hiddenmethod.filter.name=true
       public OrderedHiddenHttpMethodFilter hiddenHttpMethodFilter() {
           return new OrderedHiddenHttpMethodFilter();
       }
       ...
   }
   

   【使用表单post请求并添加_method属性的源码】

   xxxxxxxxxx
   public class HiddenHttpMethodFilter extends OncePerRequestFilter {
   
       private static final List<String> ALLOWED_METHODS =
               Collections.unmodifiableList(Arrays.asList(HttpMethod.PUT.name(),
                       HttpMethod.DELETE.name(), HttpMethod.PATCH.name()));
   
       public static final String DEFAULT_METHOD_PARAM = "_method";
   
       private String methodParam = DEFAULT_METHOD_PARAM;
       
       public void setMethodParam(String methodParam) {
           Assert.hasText(methodParam, "'methodParam' must not be empty");
           this.methodParam = methodParam;
       }
   
       @Override//执行Rest风格的请求拦截代码
       protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)
               throws ServletException, IOException {
           HttpServletRequest requestToUse = request;//原生请求的引用赋值给requestToUse
           if ("POST".equals(request.getMethod()) && request.getAttribute(WebUtils.ERROR_EXCEPTION_ATTRIBUTE) == null) {//判断原生请求的请求方式是否为post且请求没有错误
               String paramValue = request.getParameter(this.methodParam);//获取表单请求参数_method的属性值
               if (StringUtils.hasLength(paramValue)) {//判断_method的属性值是否为空串或者null
                   String method = paramValue.toUpperCase(Locale.ENGLISH);//_method的属性值全部转成大写
                   if (ALLOWED_METHODS.contains(method)) {//判断允许的请求方式是否包含_method的大写属性值，允许的请求方式ALLOWED_METHODS是一个字符串类型的List集合，内容是三个枚举PUT、DELETE、PATCH的名字
                       requestToUse = new HttpMethodRequestWrapper(request, method);//如果包含则创建一个Http请求方式的请求装饰器并赋值给requestToUse，HttpMethodRequestWrapper继承于HttpServletRequestWrapper，HttpServletRequestWrapper实现了HttpServletRequest接口，所以HttpMethodRequestWrapper还是一个原生的request请求，HttpMethodRequestWrapper把新的请求方式通过构造器传参保存在自己的method属性中并重写了getMethod方法，返回装饰器自己的method属性值而非继承来的method属性值
                   }
               }
           }
           //过滤器放行的是原生request的装饰器对象HttpMethodRequestWrapper
           filterChain.doFilter(requestToUse, response);
       }
   
       private static class HttpMethodRequestWrapper extends HttpServletRequestWrapper {
   
           private final String method;
   
           public HttpMethodRequestWrapper(HttpServletRequest request, String method) {
               super(request);
               this.method = method;
           }
   
           @Override
           public String getMethod() {
               return this.method;
           }
       }
   }
   

5. 可以使用客户端工具或者Ajax直接发送put或者delete请求

   在支持发送真实put、delete请求的场景下就没有必要使用包装类HttpMethodRequestWrapper了，此时请求方式会直接为put或者delete，直接把request赋值给requestToUse，然后立即放行requestToUse

   • PostMan可直接发送put或者delete请求

   • 安卓直接发put或者delete请求

   • Ajax直接发put或者delete请求

6. 扩展点：如何把_method这个名字换成用户自定义的

   • 要点

     • HiddenHttpMethodFilter组件如果有SpringBoot就不再自动装配，用户可以自己配置

     • HiddenHttpMethodFilter中的setMethodParam方法可以设置methodParam用自定义参数名代替_method

     xxxxxxxxxx
     public class WebMvcAutoConfiguration {
         ...    
         @Bean//hiddenHttpMethodFilter条件装配，如果自己配置了HiddenHttpMethodFilter并设置了相应的属性，SpringBoot就不会配置HiddenHttpMethodFilter组件了，利用这点用户可以配置自定义HiddenHttpMethodFilter组件，通过setMethodParam修改methodParam为自定义参数名实现自定义_method这个参数名
         @ConditionalOnMissingBean(HiddenHttpMethodFilter.class)
         @ConditionalOnProperty(prefix = "spring.mvc.hiddenmethod.filter", name = "enabled", matchIfMissing = false)
         public OrderedHiddenHttpMethodFilter hiddenHttpMethodFilter() {
             return new OrderedHiddenHttpMethodFilter();
         }   
         ...
     }
     //HiddenHttpMethodFilter中的setMethodParam方法可以设置methodParam用自定义参数名代替_method
     public class HiddenHttpMethodFilter extends OncePerRequestFilter {
         ...
         private String methodParam = DEFAULT_METHOD_PARAM;
         
         public void setMethodParam(String methodParam) {
             Assert.hasText(methodParam, "'methodParam' must not be empty");
             this.methodParam = methodParam;
         }
         ...
     }